import 'dart:async';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:cached_network_image/cached_network_image.dart';
import '../../../common/values/images.dart';
import '../../../common/routers/names.dart';
import '../../../common/api/activity_api.dart';
import '../../../common/api/friend_api.dart';
import '../../../common/utils/toast_util.dart';
import '../../../common/utils/permission_util.dart'; // 🎯 权限计算工具
import '../state.dart';
import 'activity_detail_bottom_sheet.dart';
import '../../play/plays/models/post_model.dart';
import '../../message/message_chat/controller.dart';

/// 瀑布流项目全屏卡片组件
/// 
/// 用于在全屏模式下展示瀑布流内容，包含：
/// - 全屏背景图片（支持多图左右滑动）
/// - 长条状指示器（多图时显示当前位置）
/// - 底部用户信息和描述
/// - 右侧互动按钮（点赞、踩）
class WaterfallItemCard extends StatefulWidget {
  final WaterfallItem item;
  final VoidCallback? onNext; // 切换下一个数据项的回调

  const WaterfallItemCard({
    super.key,
    required this.item,
    this.onNext,
  });

  @override
  State<WaterfallItemCard> createState() => _WaterfallItemCardState();
}

class _WaterfallItemCardState extends State<WaterfallItemCard> 
    with AutomaticKeepAliveClientMixin {
  late PageController _pageController;
  int _currentImageIndex = 0;
  bool _isExpanded = false;
  final GlobalKey _textKey = GlobalKey();
  bool? _isTextOverflowing;
  
  // 缓存图片尺寸信息
  final Map<String, Size> _imageSizeCache = {};
  final Map<String, bool> _imageSizeLoading = {};
  
  // 当前显示模式：只有两种模式
  String _currentDisplayMode = 'auto'; // 智能选择模式
  
  // 加载状态管理
  bool _isLoadingActivity = false;
  
  // 加入活动状态管理
  bool _hasJoinedActivity = false; // 是否已加入活动

  @override
  bool get wantKeepAlive => true;

  @override
  void initState() {
    super.initState();
    _pageController = PageController();
    // 预加载图片尺寸信息
    _preloadImageSizes();
  }
  
  /// 预加载所有图片的尺寸信息（异步优化，避免主线程阻塞）
  void _preloadImageSizes() {
    // 🚀 异步预加载，避免阻塞主线程
    Future.microtask(() async {
      // debugPrint('🚀 开始预加载图片尺寸: ${widget.item.imageUrls.length} 张图片');
      // debugPrint('🆔 卡片ID: ${widget.item.id}');
      
      // 限制同时预加载的图片数量，避免内存压力
      const maxConcurrent = 2;
      for (int i = 0; i < widget.item.imageUrls.length; i += maxConcurrent) {
        final batch = widget.item.imageUrls.skip(i).take(maxConcurrent);
        
        // 并行预加载当前批次的图片
        await Future.wait(batch.map((imageUrl) async {
          try {
            await _getImageSize(imageUrl);
            // 添加小延迟，让主线程有机会处理其他任务
            await Future.delayed(const Duration(milliseconds: 50));
          } catch (e) {
            // debugPrint('⚠️ 图片预加载失败: ${imageUrl.split('/').last}');
          }
        }));
      }
    });
  }
  
  /// 获取图片尺寸
  Future<Size> _getImageSize(String imageUrl) async {
    // 检查缓存
    if (_imageSizeCache.containsKey(imageUrl)) {
      return _imageSizeCache[imageUrl]!;
    }
    
    // 检查是否正在加载
    if (_imageSizeLoading[imageUrl] == true) {
      // 等待加载完成
      while (_imageSizeLoading[imageUrl] == true) {
        await Future.delayed(const Duration(milliseconds: 100));
      }
      return _imageSizeCache[imageUrl] ?? const Size(1, 1);
    }
    
    _imageSizeLoading[imageUrl] = true;
    
    try {
      final image = NetworkImage(imageUrl);
      final ImageStream stream = image.resolve(ImageConfiguration.empty);
      final completer = Completer<Size>();
      
      late ImageStreamListener listener;
      listener = ImageStreamListener((ImageInfo info, bool synchronousCall) {
        final size = Size(
          info.image.width.toDouble(),
          info.image.height.toDouble(),
        );
        _imageSizeCache[imageUrl] = size;
        _imageSizeLoading[imageUrl] = false;
        stream.removeListener(listener);
        
        // 打印图片尺寸信息
        // final aspectRatio = size.width / size.height;
        // debugPrint('📸 图片尺寸信息:');
        // debugPrint('   URL: ${imageUrl.split('/').last}'); // 只显示文件名
        // debugPrint('   尺寸: ${size.width.toInt()} x ${size.height.toInt()}');
        // debugPrint('   宽高比: ${aspectRatio.toStringAsFixed(2)}');
        // debugPrint('   ─────────────────────────────');
        
        if (!completer.isCompleted) {
          completer.complete(size);
          // 触发重建以更新显示
          if (mounted) {
            setState(() {});
          }
        }
      }, onError: (exception, stackTrace) {
        _imageSizeLoading[imageUrl] = false;
        stream.removeListener(listener);
        
        // 打印错误信息
        // debugPrint('❌ 图片加载失败:');
        // debugPrint('   URL: ${imageUrl.split('/').last}');
        // debugPrint('   错误: $exception');
        // debugPrint('   使用默认尺寸: 1x1');
        // debugPrint('   ─────────────────────────────');
        
        if (!completer.isCompleted) {
          // 默认尺寸
          completer.complete(const Size(1, 1));
        }
      });
      
      stream.addListener(listener);
      return await completer.future;
    } catch (e) {
      _imageSizeLoading[imageUrl] = false;
      
      // 打印异常信息
      // debugPrint('⚠️ 图片尺寸获取异常:');
      // debugPrint('   URL: ${imageUrl.split('/').last}');
      // debugPrint('   异常: $e');
      // debugPrint('   返回默认尺寸: 1x1');
      // debugPrint('   ─────────────────────────────');
      
      return const Size(1, 1);
    }
  }

  /// 处理查看活动详情的逻辑（简化版本 - 只显示底部弹出框）
  /// 构建联系我/我的活动按钮
  Widget _buildContactButton() {
    // 判断是否为自己发布的活动
    final bool isMyActivity = widget.item.publisherId != null && 
                             widget.item.currentUserId != null &&
                             widget.item.publisherId == widget.item.currentUserId;
    
    return GestureDetector(
      onTap: isMyActivity ? null : () => _handleContactButtonClick(),
      child: Container(
        height: 50,
        decoration: BoxDecoration(
          color: isMyActivity ? Colors.grey.shade300 : Colors.white,
          borderRadius: BorderRadius.circular(25),
        ),
        child: Center(
          child: Text(
            isMyActivity ? '我的活动' : '联系我',
            style: TextStyle(
              fontSize: 16,
              color: isMyActivity ? Colors.grey.shade600 : Colors.red,
              fontWeight: FontWeight.w600,
            ),
          ),
        ),
      ),
    );
  }

  /// 处理联系我按钮点击逻辑
  /// - 如果是好友：直接跳转到聊天界面
  /// - 如果不是好友：自动发送好友申请
  Future<void> _handleContactButtonClick() async {
    try {
      // 获取当前用户ID和发布者ID
      final currentUserId = widget.item.currentUserId;
      final publisherId = widget.item.publisherId;
      
      if (currentUserId == null || publisherId == null) {
        ToastUtil.warning('用户信息获取失败');
        return;
      }
      
      print('🔄 检查好友关系 - 当前用户: $currentUserId, 发布者: $publisherId');
      
      // 先检查好友关系
      final relationshipResponse = await FriendApi.checkFriendRelationship(
        userId: currentUserId,
        targetUserId: publisherId,
      );
      
      print('📨 好友关系查询结果: ${relationshipResponse.status}');
      
      if (relationshipResponse.isSuccess) {
        final relationshipData = relationshipResponse.data;
        
        // 判断是否已经是好友
        if (relationshipData?.isFriend == true || 
            relationshipData?.relationshipType == 'friends') {
          print('✅ 已经是好友，直接跳转到聊天界面');
          
          // 🎯 已经是好友，直接跳转到聊天界面
          Get.toNamed(
            RouteNames.messageMessageChat,
            arguments: ChatUser(
              id: publisherId.toString(),
              name: widget.item.authorName,
              avatarUrl: widget.item.authorAvatar,
            ),
          );
        } else {
          print('❌ 不是好友，发送好友申请');
          
          // 🎯 不是好友，自动发送好友申请
          await _sendFriendRequest(currentUserId, publisherId);
        }
      } else {
        print('⚠️ 好友关系查询失败，发送好友申请');
        
        // 🎯 查询失败时，尝试发送好友申请
        await _sendFriendRequest(currentUserId, publisherId);
      }
      
    } catch (e) {
      print('💥 联系我按钮处理异常: $e');
      // 🎯 异常时也尝试发送好友申请
      final currentUserId = widget.item.currentUserId;
      final publisherId = widget.item.publisherId;
      if (currentUserId != null && publisherId != null) {
        await _sendFriendRequest(currentUserId, publisherId);
      } else {
        ToastUtil.error('无法获取用户信息');
      }
    }
  }

  /// 发送好友申请
  Future<void> _sendFriendRequest(int senderId, int receiverId) async {
    try {
      print('🤝 开始发送好友申请');
      print('👤 发送者ID: $senderId');
      print('👤 接收者ID: $receiverId');
      
      // 调用发送好友申请API
      final response = await FriendApi.sendFriendRequest(
        senderId: senderId,
        receiverId: receiverId,
        message: '通过活动${widget.item.authorName}发送的好友申请', // 自定义申请消息
        free: PermissionUtil.calculateAddFriendFree(), // 🎯 动态计算加好友权限（模仿MyApplication2）
      );
      
      if (response.isSuccess) {
        // 🎯 增加加好友计数（模仿MyApplication2的逻辑）
        PermissionUtil.incrementAddFriendCount();
        
        ToastUtil.success('好友申请已发送！');
        print('✅ 好友申请发送成功');
      } else {
        if (response.message.contains('已经是好友') || response.message.contains('你们已经是好友了')) {
          // 🎯 如果返回已经是好友，直接跳转到聊天界面
          ToastUtil.info('你们已经是好友了，即将进入聊天界面');
          print('ℹ️ 好友关系状态: 已经是好友，跳转聊天界面');
          
          Get.toNamed(
            RouteNames.messageMessageChat,
            arguments: ChatUser(
              id: receiverId.toString(),
              name: widget.item.authorName,
              avatarUrl: widget.item.authorAvatar,
            ),
          );
        } else if (response.message.contains('已经发送过好友申请') || 
            response.message.contains('请等待对方处理')) {
          ToastUtil.info(response.message);
          print('ℹ️ 好友申请状态: ${response.message}');
        } else {
          ToastUtil.error('发送失败: ${response.message}');
          print('❌ 好友申请发送失败: ${response.message}');
        }
      }
      
    } catch (e) {
      print('💥 发送好友申请异常: $e');
      ToastUtil.error('发送好友申请失败');
    }
  }

  Future<void> _handleJoinActivity() async {
    // 防止重复点击
    if (_isLoadingActivity) {
      print('🚫 正在加载中，忽略重复点击');
      return;
    }
    
    try {
      // 检查是否为活动类型
      if (widget.item.type != 'activity') {
        ToastUtil.warning('只有活动可以查看详情');
        return;
      }
      
      // 提取活动ID
      final activityIdStr = widget.item.id.replaceFirst('real_activity_', '');
      final activityId = int.tryParse(activityIdStr);
      
      if (activityId == null) {
        ToastUtil.error('活动ID格式错误');
        return;
      }
      
      // 设置加载状态
      setState(() {
        _isLoadingActivity = true;
      });
      
      print('🔄 开始加载活动详情，ID: $activityId');
      
      // 🚀 带超时的API调用
      final response = await ActivityApi.getActivityDetail(
        activityId: activityId,
      ).timeout(
        const Duration(seconds: 8),
        onTimeout: () {
          print('⏰ API调用超时');
          return {'status': 'timeout', 'message': '网络超时'};
        },
      );
      
      print('📨 活动详情API响应状态: ${response['status']}');
      
      // 🎯 解析API响应数据
      PostModel activity;
      
      if (response['status'] == 'success') {
        print('✅ 活动详情加载成功');
        
        // 📊 从API响应中提取activity数据
        final responseData = response['activity'] ?? response['data'];
        
        activity = PostModel(
          id: widget.item.id,
          title: responseData?['activityTitle']?.toString() ?? widget.item.title,
          content: responseData?['activityDetails']?.toString() ?? widget.item.description,
          authorName: responseData?['publisherNickname']?.toString() ?? widget.item.authorName,
          authorAvatar: responseData?['publisherAvatar']?.toString() ?? widget.item.authorAvatar,
          images: (responseData?['activityImages'] as List?)?.cast<String>() ?? widget.item.imageUrls,
          likeCount: 0,
          commentCount: 0,
          timeAgo: '${responseData?['activityCurrentParticipants'] ?? 0}/${responseData?['activityMaxParticipants'] ?? 0}人',
          type: PostType.activity,
          authorSignature: responseData?['publisherSignature']?.toString() ?? '这个人很懒，什么都没留下',
          paymentType: (responseData?['activityType'] as List?)?.join(', ') ?? '我买单',
          // 🔥 添加时间相关字段（与MyApplication2一致）
          activityPublishTime: responseData?['activityPublishTime']?.toString(),
          publishTime: responseData?['activityPublishTime']?.toString(), // 保持兼容性
          extraData: responseData?['extraData'] != null 
              ? ActivityExtraData.fromJson(responseData!['extraData'] as Map<String, dynamic>)
              : null, // 🔥 传递extraData
          // 活动专用字段
          maxParticipants: responseData?['activityMaxParticipants'] as int? ?? 0,
          currentParticipants: responseData?['activityCurrentParticipants'] as int? ?? 0,
          location: responseData?['activityLocation']?.toString() ?? widget.item.location,
          activityType: (responseData?['activityType'] as List?)?.cast<String>(),
          activityTags: (responseData?['activityTags'] as List?)?.cast<String>(),
          authorId: responseData?['publisherId'] as int?, // 🎯 添加发布者ID字段
          latitude: responseData?['latitude'] as double? ?? widget.item.latitude, // 添加latitude
          longitude: responseData?['longitude'] as double? ?? widget.item.longitude, // 添加longitude
          gender: responseData?['publisherGender']?.toString() ?? widget.item.gender, // 添加gender
          activityRestriction: (responseData?['activityRestriction'] as List?)?.cast<String>() ?? widget.item.activityRestriction, // 添加activityRestriction
        );
      } else {
        print('⚠️ API调用失败，使用本地数据');
        
        // 使用本地数据
        activity = PostModel(
          id: widget.item.id,
          title: widget.item.title,
          content: widget.item.description,
          authorName: widget.item.authorName,
          authorAvatar: widget.item.authorAvatar,
          images: widget.item.imageUrls,
          likeCount: 0,
          commentCount: 0,
          timeAgo: widget.item.time ?? '未知时间',
          type: PostType.activity,
          authorSignature: '这个人很懒，什么都没留下',
          paymentType: widget.item.activityType ?? '我买单',
          location: widget.item.location,
          latitude: widget.item.latitude, // 传递latitude
          longitude: widget.item.longitude, // 传递longitude
          gender: widget.item.gender, // 传递gender
          activityRestriction: widget.item.activityRestriction, // 传递activityRestriction
        );
      }
      
      // 🎯 直接显示底部弹出框（不要await，避免阻塞）
      print('🎉 显示活动详情弹出框');
      ActivityDetailBottomSheet.show(
        activity: activity,
        onJoinSuccess: () {
          // 加入活动成功的回调
          if (mounted) {
            setState(() {
              _hasJoinedActivity = true;
            });
            print('✅ 更新主界面加入状态: $_hasJoinedActivity');
          }
        },
      );
      
    } catch (e) {
      print('💥 查看活动详情异常: $e');
      
      // 🔄 异常时也显示弹出框（使用本地数据）
      final fallbackActivity = PostModel(
        id: widget.item.id,
        title: widget.item.title,
        content: widget.item.description,
        authorName: widget.item.authorName,
        authorAvatar: widget.item.authorAvatar,
        images: widget.item.imageUrls,
        likeCount: 0,
        commentCount: 0,
        timeAgo: widget.item.time ?? '未知时间',
        type: PostType.activity,
        authorSignature: '这个人很懒，什么都没留下',
        paymentType: widget.item.activityType ?? '我买单',
        location: widget.item.location,
        latitude: widget.item.latitude, // 传递latitude
        longitude: widget.item.longitude, // 传递longitude
        gender: widget.item.gender, // 传递gender
        activityRestriction: widget.item.activityRestriction, // 传递activityRestriction
      );
      
      ActivityDetailBottomSheet.show(
        activity: fallbackActivity,
        onJoinSuccess: () {
          // 加入活动成功的回调
          if (mounted) {
            setState(() {
              _hasJoinedActivity = true;
            });
            print('✅ 更新主界面加入状态: $_hasJoinedActivity');
          }
        },
      );
    } finally {
      // 清除加载状态
      if (mounted) {
        setState(() {
          _isLoadingActivity = false;
        });
      }
      print('🏁 活动详情处理完成');
    }
  }

  @override
  void dispose() {
    // 打印缓存统计信息
    // debugPrint('📊 组件销毁 - 图片缓存统计:');
    // debugPrint('   卡片ID: ${widget.item.id}');
    // debugPrint('   缓存图片数量: ${_imageSizeCache.length}');
    // debugPrint('   正在加载的图片: ${_imageSizeLoading.values.where((loading) => loading).length}');
    // _imageSizeCache.forEach((url, size) {
    //   final ratio = size.width / size.height;
    //   debugPrint('   ✓ ${url.split('/').last}: ${size.width.toInt()}x${size.height.toInt()} (${ratio.toStringAsFixed(2)})');
    // });
    // debugPrint('   ═════════════════════════════');
    
    _pageController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    super.build(context);
    return RepaintBoundary(
      child: Container(
        width: double.infinity,
        height: double.infinity,
        color: Colors.black,
        child: Stack(
          children: [
            // 全屏背景图片（支持多图滑动）
            Positioned.fill(
              child: _buildImageViewer(),
            ),
          
          // 长条状指示器（只在多图时显示）
          if (widget.item.imageUrls.length > 1)
            Positioned(
              top: MediaQuery.of(context).padding.top + 20,
              left: 0,
              right: 0,
              child: Center(
                child: Container(
                  width: MediaQuery.of(context).size.width * 0.8, // 比屏幕宽度稍小
                  height: 3,
                  child: Row(
                    children: List.generate(
                      widget.item.imageUrls.length * 2 - 1, // 长条数量 + 间隔数量
                      (index) {
                        if (index.isOdd) {
                          // 奇数索引为间隔
                          return const SizedBox(width: 4);
                        } else {
                          // 偶数索引为长条
                          final barIndex = index ~/ 2;
                          return Expanded(
                            child: AnimatedContainer(
                              duration: const Duration(milliseconds: 300),
                              curve: Curves.easeInOut,
                              height: 3,
                              decoration: BoxDecoration(
                                color: _currentImageIndex == barIndex
                                    ? Colors.white
                                    : Colors.white.withValues(alpha: 0.3),
                                borderRadius: BorderRadius.circular(1.5),
                              ),
                            ),
                          );
                        }
                      },
                    ),
                  ),
                ),
              ),
            ),
          
            
          // 底部信息区域
          Positioned(
            left: 0,
            right: 0,
            bottom: 0,
            child: Container(
              decoration: BoxDecoration(
                gradient: LinearGradient(
                  begin: Alignment.topCenter,
                  end: Alignment.bottomCenter,
                  colors: [
                    Colors.transparent,
                    Colors.black.withValues(alpha: 0.3),
                    Colors.black.withValues(alpha: 0.7),
                  ],
                ),
              ),
              padding: const EdgeInsets.fromLTRB(16, 40, 16, 20),
              child: SafeArea(
                top: false,
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  mainAxisSize: MainAxisSize.min,
                  children: [
                    // 用户信息区域（现在在上面）
                    Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Row(
                          mainAxisSize: MainAxisSize.min,
                          children: [
                            Text(
                              widget.item.authorName,
                              style: const TextStyle(
                                fontSize: 16,
                                color: Colors.white,
                                fontWeight: FontWeight.w600,
                              ),
                              overflow: TextOverflow.ellipsis,
                            ),
                            const SizedBox(width: 4),
                            _buildGenderIcon(),
                          ],
                        ),
                        const SizedBox(height: 4),
                        // 距离信息（使用真实计算的距离）
                        Row(
                          children: [
                            Image.asset(
                              AssetsImages.locationPng,
                              width: 14,
                              height: 14,
                              color: Colors.white70,
                            ),
                            const SizedBox(width: 4),
                            Text(
                              widget.item.distance ?? '距离未知',
                              style: const TextStyle(
                                fontSize: 12,
                                color: Colors.white70,
                              ),
                            ),
                          ],
                        ),
                      ],
                    ),
                    const SizedBox(height: 12),
                    
                    // 描述文本（现在在下面）
                    _buildDescriptionArea(),
                    const SizedBox(height: 20),
                    
                    // 底部按钮区域 - 居中显示，统一间距
                    Row(
                      mainAxisAlignment: MainAxisAlignment.center, // 三个按钮居中显示
                      children: [
                        // X 按钮
                        GestureDetector(
                          onTap: () {
                            // 点击 X 按钮切换下一个数据项
                            widget.onNext?.call();
                          },
                          child: Container(
                            width: 50,
                            height: 50,
                            decoration: BoxDecoration(
                              color: Colors.blue,
                              shape: BoxShape.circle,
                            ),
                            child: const Icon(
                              Icons.close,
                              color: Colors.white,
                              size: 24,
                            ),
                          ),
                        ),
                        const SizedBox(width: 16), // 统一间距为16
                        
                        // 联系我/我的活动按钮
                        SizedBox(
                          width: 140, // 缩小宽度
                          child: _buildContactButton(),
                        ),
                        const SizedBox(width: 12), // 统一间距为16
                        
                        // 加入按钮（带加载状态和已加入状态）
                        GestureDetector(
                          onTap: _isLoadingActivity ? null : () => _handleJoinActivity(),
                          child: SizedBox(
                            width: 55,
                            height: 55,
                            child: Stack(
                              children: [
                                // 爱心图标（根据状态改变颜色）
                                Positioned(
                                  left: 0,
                                  top: 0,
                                  child: Icon(
                                    Icons.favorite,
                                    color: _getHeartColor(),
                                    size: 57,
                                  ),
                                ),
                                // 文字或加载指示器
                                Positioned(
                                  left: 0,
                                  top: -2,
                                  width: 57,
                                  height: 57,
                                  child: Center(
                                    child: _isLoadingActivity
                                        ? const SizedBox(
                                            width: 16,
                                            height: 16,
                                            child: CircularProgressIndicator(
                                              strokeWidth: 2,
                                              valueColor: AlwaysStoppedAnimation<Color>(Colors.white),
                                            ),
                                          )
                                        : Text(
                                            _getButtonText(),
                                            style: const TextStyle(
                                              fontSize: 12,
                                              color: Colors.white,
                                              fontWeight: FontWeight.w600,
                                            ),
                                          ),
                                  ),
                                ),
                              ],
                            ),
                          ),
                        ),
                      ],
                    ),
                  ],
                ),
              ),
            ),
          ),
          ],
        ),
      ),
    );
  }

  /// 构建图片查看器（支持多图滑动）
  Widget _buildImageViewer() {
    if (widget.item.imageUrls.length <= 1) {
      // 单图直接显示
      return _buildSmartImage(widget.item.coverUrl);
    }

    // 多图使用 PageView 支持左右滑动
    return PageView.builder(
      controller: _pageController,
      onPageChanged: (index) {
        setState(() {
          _currentImageIndex = index;
        });
      },
      itemCount: widget.item.imageUrls.length,
      itemBuilder: (context, index) {
        return _buildSmartImage(widget.item.imageUrls[index]);
      },
    );
  }

  /// 智能图片显示组件 - 根据图片实际尺寸智能选择显示方式
  Widget _buildSmartImage(String imageUrl) {
    return RepaintBoundary(
      child: InteractiveViewer(
        panEnabled: true,
        scaleEnabled: true,
        minScale: 1.0,
        maxScale: 3.0,
        child: LayoutBuilder(
          builder: (context, constraints) {
            // 智能选择显示模式
            String displayMode = _currentDisplayMode;
            
            // 🔥 修复：如果是智能模式，根据图片比例自动选择
            if (_currentDisplayMode == 'auto' && _imageSizeCache.containsKey(imageUrl)) {
              final imageSize = _imageSizeCache[imageUrl]!;
              final aspectRatio = imageSize.width / imageSize.height;
              
              // 🔥 修复：参考MyApplication2的CENTER_CROP策略
              // MyApplication2一律使用CENTER_CROP，我们也应该主要使用cover模式
              // 只有在极端比例的图片下才考虑使用contain
              if (aspectRatio > 3.0 || aspectRatio < 0.3) {
                displayMode = 'fit';   // 极端比例图片 → 完整显示，避免过度裁切
              } else {
                displayMode = 'fill';  // 正常比例图片 → 填满屏幕，类似CENTER_CROP
              }
            }
            
            final boxFit = _getManualBoxFit(displayMode);
            // final alignment = _getImageAlignment(boxFit); // 未使用，已删除
            
            // debugPrint('🎯 显示模式:');
            // debugPrint('   文件: ${imageUrl.split('/').last}');
            // if (_currentDisplayMode == 'auto') {
            //   debugPrint('   智能模式 → 自动选择: $displayMode');
            // }
            // debugPrint('   BoxFit: ${boxFit.toString().split('.').last}');
            // debugPrint('   对齐方式: ${_getAlignmentDescription(alignment)}');
            // 
            // // 显示详细的图片尺寸信息
            // if (_imageSizeCache.containsKey(imageUrl)) {
            //   final imageSize = _imageSizeCache[imageUrl]!;
            //   final aspectRatio = imageSize.width / imageSize.height;
            //   debugPrint('   📐 图片尺寸详情:');
            //   debugPrint('      宽度: ${imageSize.width.toInt()} px');
            //   debugPrint('      高度: ${imageSize.height.toInt()} px');
            //   debugPrint('      宽高比: ${aspectRatio.toStringAsFixed(3)} (${aspectRatio.toStringAsFixed(1)}:1)');
            //   debugPrint('      图片类型: ${_getImageTypeDescription(aspectRatio)}');
            //   if (_currentDisplayMode == 'auto') {
            //     debugPrint('      智能策略: ${aspectRatio > 1.4 ? "过宽横向→完整显示" : "竖向/方形→填满屏幕"}');
            //   }
            // }
            // 
            // debugPrint('   ═════════════════════════════');
            
            return Stack(
              children: [
                // 🔥 修复图片容器 - 避免强制拉伸
                Container(
                  width: double.infinity,
                  height: double.infinity,
                  color: Colors.black,
                  child: CachedNetworkImage(
                    imageUrl: imageUrl,
                    fit: boxFit,
                    alignment: _getImageAlignment(boxFit), // 智能对齐
                    placeholder: (context, url) => Container(
                      color: Colors.grey[50],
                      // 移除loading动画，直接显示空白背景
                    ),
                    errorWidget: (context, url, error) => Container(
                      color: Colors.grey[200],
                      child: const Center(
                        child: Icon(
                          Icons.image_not_supported,
                          color: Colors.grey,
                          size: 40,
                        ),
                      ),
                    ),
                    // 缓存配置 - 提升加载速度
                    memCacheWidth: 720,  // 内存缓存宽度
                    memCacheHeight: 1280, // 内存缓存高度
                    maxWidthDiskCache: 720, // 磁盘缓存最大宽度
                    maxHeightDiskCache: 1280, // 磁盘缓存最大高度
                  ),
                ),
              ],
            );
          },
        ),
      ),
    );
  }

  /// 构建描述文本区域（支持展开/收起）
  Widget _buildDescriptionArea() {
    return LayoutBuilder(
      builder: (context, constraints) {
        // 缓存文本溢出计算结果
        _isTextOverflowing ??= _calculateTextOverflow(constraints.maxWidth - 60);
        final isOverflowing = _isTextOverflowing!;
        
        if (isOverflowing || _isExpanded) {
          // 有展开按钮时，使用Row布局
          return Row(
            crossAxisAlignment: CrossAxisAlignment.end,
            children: [
              // 左侧文本内容
              Expanded(
                child: AnimatedContainer(
                  duration: const Duration(milliseconds: 200),
                  child: Text(
                    widget.item.description,
                    key: _textKey,
                    style: const TextStyle(
                      fontSize: 14,
                      color: Colors.white,
                      fontWeight: FontWeight.w400,
                      height: 1.4,
                    ),
                    maxLines: _isExpanded ? null : 2,
                    overflow: _isExpanded ? TextOverflow.visible : TextOverflow.ellipsis,
                  ),
                ),
              ),
              const SizedBox(width: 8),
              // 右侧展开按钮
              GestureDetector(
                onTap: () {
                  setState(() {
                    _isExpanded = !_isExpanded;
                  });
                },
                child: Container(
                  padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
                  decoration: BoxDecoration(
                    color: Colors.grey.withValues(alpha: 0.8),
                    borderRadius: BorderRadius.circular(4),
                  ),
                  child: Text(
                    _isExpanded ? '收起' : '展开',
                    style: const TextStyle(
                      color: Colors.white,
                      fontSize: 12,
                      fontWeight: FontWeight.w500,
                    ),
                  ),
                ),
              ),
            ],
          );
        } else {
          // 没有展开按钮时，直接显示文本
          return Text(
            widget.item.description,
            style: const TextStyle(
              fontSize: 14,
              color: Colors.white,
              fontWeight: FontWeight.w400,
              height: 1.4,
            ),
          );
        }
      },
    );
  }

  bool _calculateTextOverflow(double maxWidth) {
    final textSpan = TextSpan(
      text: widget.item.description,
      style: const TextStyle(
        fontSize: 14,
        color: Colors.white,
        fontWeight: FontWeight.w400,
        height: 1.4,
      ),
    );
    
    final textPainter = TextPainter(
      text: textSpan,
      maxLines: 2,
      textDirection: TextDirection.ltr,
    );
    textPainter.layout(maxWidth: maxWidth);
    
    return textPainter.didExceedMaxLines;
  }

  /// 构建性别图标 - 根据数据动态生成
  Widget _buildGenderIcon() {
    // 🎯 根据用户数据动态判断性别，而不是使用固定的ID哈希
    bool isMale = _getGenderFromData();
    
    Widget iconStack = Stack(
      children: [
        // 底层阴影效果，模拟加粗
        Icon(
          isMale ? Icons.male : Icons.female,
          color: (isMale ? Colors.blue : Colors.pink).withValues(alpha: 0.3),
          size: 20.5,
        ),
        // 顶层主图标
        Icon(
          isMale ? Icons.male : Icons.female,
          color: isMale ? Colors.blue : Colors.pink,
          size: 20,
        ),
      ],
    );

    // 女性图标左下旋转15度
    if (!isMale) {
      return Transform.rotate(
        angle: 0.0, // 15度转弧度
        child: iconStack,
      );
    }
    
    return iconStack;
  }
  
  /// 🎯 根据数据智能判断性别
  bool _getGenderFromData() {
    // 🎯 优先级1: 使用API返回的真实性别数据
    if (widget.item.gender != null && widget.item.gender!.isNotEmpty) {
      final gender = widget.item.gender!.toLowerCase();
      print('🔍 使用API性别数据: ${widget.item.gender} -> ${gender == '男' || gender == 'male' ? '男性' : '女性'}');
      return gender == '男' || gender == 'male';
    }
    
    print('⚠️ 未找到API性别数据，使用智能判断逻辑');
    
    // 优先级2: 根据用户名特征判断
    final name = widget.item.authorName.toLowerCase();
    
    // 常见女性名字特征
    final femaleIndicators = [
      '小美', '小丽', '小芳', '小红', '小花', '小燕', '小雪', '小月', '小玉', '小娟',
      '美', '丽', '芳', '红', '花', '燕', '雪', '月', '玉', '娟', '婷', '静', '雅', '欣',
      'girl', 'lady', 'miss', 'woman', '女', '姐', '妹', '娘', '嫂',
      '晓', '小晴', '小雨', '小云', '小霞', '小春', '小秋', '小冬', '小夏',
      '林', '李', '王', '张', '刘', '陈', '杨', '赵', '黄', '周'
    ];
    
    // 常见男性名字特征  
    final maleIndicators = [
      '小明', '小强', '小军', '小华', '小刚', '小伟', '小磊', '小涛', '小峰', '小龙',
      '明', '强', '军', '华', '刚', '伟', '磊', '涛', '峰', '龙', '虎', '豹', '鹏', '飞',
      'boy', 'man', 'sir', 'mr', '男', '哥', '弟', '叔', '爸',
      '大', '老', '阿'
    ];
    
    // 检查女性特征
    for (final indicator in femaleIndicators) {
      if (name.contains(indicator)) {
        return false; // 女性
      }
    }
    
    // 检查男性特征
    for (final indicator in maleIndicators) {
      if (name.contains(indicator)) {
        return true; // 男性
      }
    }
    
    // 优先级3: 根据用户ID或其他数据特征判断
    // 使用更复杂的算法，结合多个因素
    final userId = widget.item.publisherId ?? 0;
    final nameLength = widget.item.authorName.length;
    final itemIdHash = widget.item.id.hashCode;
    
    // 综合判断算法：结合用户ID、姓名长度、项目ID等多个因素
    final genderScore = (userId % 7) + (nameLength % 3) + (itemIdHash % 5);
    
    // 如果综合得分为偶数，则为男性；奇数为女性
    // 这样可以保证同一个用户的性别保持一致，但不同用户间有变化
    return genderScore % 2 == 0;
  }

  // 删除未使用的方法: _getImageTypeDescription
  

  
  /// 根据模式名称获取BoxFit
  BoxFit _getManualBoxFit(String mode) {
    switch (mode) {
      case 'fill':
        return BoxFit.cover;   // 🔥 修复：使用cover避免拉伸，类似Android的CENTER_CROP
      case 'fit':
        return BoxFit.contain; // 完整显示
      case 'auto':
        return BoxFit.cover;   // 🔥 修复：智能模式默认使用cover，避免拉伸
      default:
        return BoxFit.cover;   // 🔥 修复：默认使用cover，确保图片比例正确
    }
  }
  

  
  /// 根据BoxFit模式获取合适的图片对齐方式
  Alignment _getImageAlignment(BoxFit boxFit) {
    switch (boxFit) {
      case BoxFit.contain:
        // 完整显示模式：图片往上靠，避免遮挡底部用户信息
        return const Alignment(0.0, -0.3); // 稍微偏上，为底部信息留空间
      case BoxFit.cover:
      default:
        // 填满屏幕模式：使用居中对齐
        return Alignment.center;
    }
  }
  
  // 删除未使用的方法: _getAlignmentDescription
  
  /// 获取心形图标颜色
  Color _getHeartColor() {
    if (_isLoadingActivity) {
      return Colors.red.withOpacity(0.6); // 加载时半透明红色
    } else if (_hasJoinedActivity) {
      return Colors.green; // 已加入时绿色
    } else {
      return Colors.red; // 默认红色
    }
  }
  
  /// 获取按钮文字
  String _getButtonText() {
    if (_hasJoinedActivity) {
      return '已申请'; // 已加入时显示"已申请"
    } else {
      return '加入'; // 默认显示"加入"
    }
  }
  

  
}